/**
 * @date: 2025/3/20
 * @author: 小红
 * @fileName: useEmitter
 * @Description: 全局通知 解耦
 */

export type EventType = string | symbol

// 事件处理程序可以采用可选的事件参数 并且不应返回值
export type Handler<T = unknown> = (event: T) => void
export type WildcardHandler<T = Record<string, unknown>> = (
  type: keyof T,
  event: T[keyof T],
) => void

// 一个类型当前注册的所有事件处理程序的数组
export type EventHandlerList<T = unknown> = Array<Handler<T>>
export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>

// 事件类型及其相应事件处理程序的映射。
export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
  keyof Events | '*',
  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
>

export interface Emitter<Events extends Record<EventType, unknown>> {
  all: EventHandlerMap<Events>

  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void

  on(type: '*', handler: WildcardHandler<Events>): void

  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void

  off(type: '*', handler: WildcardHandler<Events>): void

  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void

  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void
}

/**
 * Mitt: Tiny (~200b) functional event emitter / pubsub.
 * @name mitt
 */
function mitt<Events extends Record<EventType, unknown>>(
  all?: EventHandlerMap<Events>,
): Emitter<Events> {
  type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>
  all = all || new Map()

  return {
    /**
     * 事件名称到已注册处理程序函数的 Map。
     */
    all,

    /**
     * 为给定类型注册事件处理程序。
     * @param {string|symbol} type 要侦听的事件类型，或 ''*'' 表示所有事件
     * @param {Function} handler 为响应给定事件而调用的函数
     * @memberOf mitt
     */
    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {
      const handlers: Array<GenericEventHandler> | undefined = all!.get(type)
      if (handlers) {
        handlers.push(handler)
      } else {
        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>)
      }
    },

    /**
     * 删除给定类型的事件处理程序。
     * 如果省略 'handler' ，则删除给定类型的所有处理程序。
     * @param {string|symbol} type 要从中注销 'handler' 的事件类型（''*'' 以删除通配符处理程序）
     * @param {Function} [handler] 要删除的处理程序函数
     * @memberOf mitt
     */
    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
      const handlers: Array<GenericEventHandler> | undefined = all!.get(type)
      if (handlers) {
        if (handler) {
          handlers.splice(handlers.indexOf(handler) >>> 0, 1)
        } else {
          all!.set(type, [])
        }
      }
    },

    /**
     * 调用给定类型的所有处理程序。
     * 如果存在，则在 type-matched 处理程序之后调用 ''*'' 处理程序。
     *
     * Note: Manually firing '*' handlers is not supported.
     *
     * @param {string|symbol} type The event type to invoke
     * @param {any} [evt] 传递给每个处理程序的任何值（推荐且功能强大的 object）
     * @memberOf mitt
     */
    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
      let handlers = all!.get(type)
      if (handlers) {
        ;(handlers as EventHandlerList<Events[keyof Events]>).slice().map((handler) => {
          handler(evt!)
        })
      }

      handlers = all!.get('*')
      if (handlers) {
        ;(handlers as WildCardEventHandlerList<Events>).slice().map((handler) => {
          handler(type, evt!)
        })
      }
    },
  }
}

export default mitt()
